home *** CD-ROM | disk | FTP | other *** search
/ Nebula 1 / Nebula One.iso / Graphics / Plotting / aa_Intel_Only / Gnuplot / GnuplotSource / StatusContour.m < prev    next >
Encoding:
Text File  |  1995-06-12  |  6.5 KB  |  398 lines
  1. /*
  2.  *  Copyright (C) 1993  Robert Davis
  3.  *
  4.  *  This program is free software; you can redistribute it and/or
  5.  *  modify it under the terms of Version 2, or any later version, of 
  6.  *  the GNU General Public License as published by the Free Software 
  7.  *  Foundation.
  8.  */
  9.  
  10.  
  11. static char RCSId[]="$Id: StatusContour.m,v 1.10 1993/05/18 03:55:42 davis Exp $";
  12.  
  13.  
  14.  
  15. #import "DoubleObject.h"
  16. #import "DoubleValueSortedList.h"
  17. #import "StatusContour.h"
  18.  
  19. #define MAX_DISCRETE_LEVELS    30
  20.  
  21. extern int    draw_contour;
  22. extern int    contour_kind;
  23. extern int    contour_pts;
  24. extern int    contour_order;
  25. extern int    contour_levels;
  26. extern int    levels_kind;
  27. extern double    levels_list[MAX_DISCRETE_LEVELS];
  28. extern int    label_contours;
  29.  
  30. @implementation Status (Contour)
  31.  
  32. - initContour
  33. {
  34.     levelDefs = nil;
  35.     return self;
  36. }
  37.  
  38.  
  39. - freeContour
  40. {
  41.     if (levelDefs)
  42.     [[levelDefs freeObjects] free];
  43.  
  44.     return self;
  45. }
  46.  
  47.  
  48. - resetCurrentContour
  49. {
  50.     contourBase = NO;
  51.     contourSurface = NO;
  52.     s_contour_kind = CONTOUR_KIND_LINEAR;
  53.     s_contour_pts = 5;
  54.     s_contour_order = 4;
  55.     s_contour_levels = 5;
  56.     s_levels_kind = LEVELS_AUTO;
  57.     s_levelsSeries.start = -1.0;
  58.     s_levelsSeries.incr = .25;
  59.     s_levelsSeries.end = 1.0;
  60.     s_label_contours = YES;
  61.  
  62.     if (levelDefs)
  63.     [levelDefs freeObjects];
  64.     else {
  65.     levelDefs = [[DoubleValueSortedList allocFromZone:zone] init];
  66.     [levelDefs setMax:MAX_DISCRETE_LEVELS];
  67.     }
  68.  
  69.     return self;
  70. }
  71.  
  72.  
  73. - applyCurrentContour
  74. {
  75.     int i;
  76.  
  77.     if (!contourBase && !contourSurface)
  78.     draw_contour = CONTOUR_NONE;
  79.     else if (contourBase && contourSurface)
  80.     draw_contour = CONTOUR_BOTH;
  81.     else if (contourBase)
  82.     draw_contour = CONTOUR_BASE;
  83.     else if (contourSurface)
  84.     draw_contour = CONTOUR_SRF;
  85.  
  86.     contour_kind = s_contour_kind;
  87.     contour_pts = s_contour_pts;
  88.     contour_order = s_contour_order;
  89.  
  90.     switch (levels_kind = s_levels_kind) {
  91.     case LEVELS_INCREMENTAL:
  92.     levels_list[0] = s_levelsSeries.start;
  93.     levels_list[1] = s_levelsSeries.incr;
  94.     contour_levels = (s_levelsSeries.end - s_levelsSeries.start)
  95.                 / s_levelsSeries.incr;
  96.     break;
  97.     case LEVELS_DISCRETE:
  98.     contour_levels = [levelDefs count];
  99.     for (i = 0; i < contour_levels; i++)
  100.          levels_list[i] = [[levelDefs objectAt:i] doubleValue];
  101.     break;
  102.     default:
  103.     contour_levels = s_contour_levels;
  104.     }
  105.  
  106.     label_contours = s_label_contours;
  107.  
  108.     return self;
  109. }
  110.  
  111.  
  112. - grabCurrentContour
  113. {
  114.     int i, maxi;
  115.  
  116.     switch (draw_contour) {
  117.     case CONTOUR_NONE:
  118.     contourBase = contourSurface = NO;
  119.     break;
  120.     case CONTOUR_BASE:
  121.     contourBase = YES;
  122.     contourSurface = NO;
  123.     break;
  124.     case CONTOUR_SRF:
  125.     contourBase = NO;
  126.     contourSurface = YES;
  127.     break;
  128.     default:
  129.     contourBase = YES;
  130.     contourSurface = YES;
  131.     break;
  132.     }
  133.  
  134.     switch (s_levels_kind = levels_kind) {
  135.     case LEVELS_INCREMENTAL:
  136.     s_levelsSeries.start = levels_list[0];
  137.     s_levelsSeries.incr = levels_list[1];
  138.     s_levelsSeries.end = (contour_levels * levels_list[1]) +levels_list[0];
  139.     s_contour_levels = contour_levels;
  140.     break;
  141.     case LEVELS_DISCRETE:
  142.     maxi = [levelDefs count] - 1;
  143.     for (i = 0; i < contour_levels; i++) {
  144.         if (i <= maxi)
  145.         [[levelDefs objectAt:i] setDoubleValue:levels_list[i]];
  146.         else {
  147.         DoubleObject *dobj = [[DoubleObject allocFromZone:zone]
  148.                         initFromDouble:levels_list[i]];
  149.         if ([levelDefs addObjectIfDoubleAbsent:dobj] == NX_NOT_IN_LIST)
  150.             [dobj free];
  151.         }
  152.     }
  153.     s_contour_levels = [levelDefs count];
  154.     break;
  155.     case LEVELS_AUTO:
  156.     s_contour_levels = contour_levels;
  157.     break;
  158.     }
  159.  
  160.     s_contour_pts = contour_pts;
  161.     s_contour_order = contour_order;
  162.     s_levels_kind = levels_kind;
  163.     s_label_contours = label_contours;
  164.  
  165.     return self;
  166. }
  167.  
  168.  
  169.  
  170. - setContourBase:(BOOL) cond
  171. {
  172.     if (contourBase != cond) {
  173.     contourBase = cond;
  174.     [self reportSettingsChange:self];
  175.     }
  176.  
  177.     return self;
  178. }
  179.  
  180.  
  181. - (BOOL) contourBase
  182. {
  183.     return contourBase;
  184. }
  185.  
  186.  
  187.  
  188. - setContourSurface:(BOOL) cond
  189. {
  190.     if (contourSurface != cond) {
  191.     contourSurface = cond;
  192.     [self reportSettingsChange:self];
  193.     }
  194.  
  195.     return self;
  196. }
  197.  
  198.  
  199. - (BOOL) contourSurface
  200. {
  201.     return contourSurface;
  202. }
  203.  
  204.  
  205.  
  206. - setContourKind:(int) anInt
  207. {
  208.     if (anInt != s_contour_kind) {
  209.     s_contour_kind = anInt;
  210.     [self reportSettingsChange:self];
  211.     }
  212.  
  213.     return self;
  214. }
  215.  
  216.  
  217.  
  218. - (int) contourKind;
  219. {
  220.     return s_contour_kind;
  221. }
  222.  
  223.  
  224.  
  225. - setContourPoints:(int) anInt
  226. {
  227.     if ((anInt != s_contour_pts) && (anInt > 0)) {
  228.     s_contour_pts = anInt;
  229.     [self reportSettingsChange:self];
  230.     }
  231.  
  232.     return self;
  233. }
  234.  
  235.  
  236. - (int) contourPoints
  237. {
  238.     return s_contour_pts;
  239. }
  240.  
  241.  
  242.  
  243. - setContourOrder:(int) anInt
  244. {
  245.     if ((anInt != s_contour_order) && (anInt >= 2) && (anInt <= 10)) {
  246.     s_contour_order = anInt;
  247.     [self reportSettingsChange:self];
  248.     }
  249.  
  250.     return self;
  251. }
  252.  
  253.  
  254. - (int) contourOrder
  255. {
  256.     return s_contour_order;
  257. }
  258.  
  259.  
  260. - setContourLevels:(int) anInt
  261. {
  262.     if (anInt != [self contourLevels] && (anInt > 0)) {
  263.     if (s_levels_kind == LEVELS_INCREMENTAL) {
  264.         s_levelsSeries.end = (anInt * s_levelsSeries.incr) +
  265.                             s_levelsSeries.start;
  266.     } else if (s_levels_kind == LEVELS_AUTO) {
  267.         s_contour_levels = anInt;
  268.     }
  269.  
  270.     [self reportSettingsChange:self];
  271.     }
  272.  
  273.     return self;
  274. }
  275.  
  276.  
  277. - (int) contourLevels
  278. {
  279.     switch (s_levels_kind) {
  280.     case LEVELS_INCREMENTAL:
  281.     return (s_levelsSeries.end -s_levelsSeries.start) /s_levelsSeries.incr;
  282.     case LEVELS_DISCRETE:
  283.     return [levelDefs count];
  284.     default:
  285.     return s_contour_levels;
  286.     }
  287. }
  288.  
  289.  
  290. - setContourLevelsKind:(int) anInt;
  291. {
  292.     if (anInt != s_levels_kind) {
  293.     s_levels_kind = anInt;
  294.     [self reportSettingsChange:self];
  295.     }
  296.  
  297.     return self;
  298. }
  299.  
  300.  
  301.  
  302. - (int) contourLevelsKind
  303. {
  304.     return s_levels_kind;
  305. }
  306.  
  307.  
  308.  
  309. - setContourLevelsStart:(double)aDouble
  310. {
  311.     if (aDouble != s_levelsSeries.start) {
  312.     s_levelsSeries.start = aDouble;
  313.     [self reportSettingsChange:self];
  314.     }
  315.  
  316.     return self;
  317. }
  318.  
  319.  
  320.  
  321. - (double)contourLevelsStart
  322. {
  323.     return s_levelsSeries.start;
  324. }
  325.  
  326.  
  327.  
  328. - setContourLevelsIncr:(double)aDouble
  329. {
  330.     if (aDouble && (aDouble != s_levelsSeries.incr)) {
  331.     s_levelsSeries.incr = aDouble;
  332.     [self reportSettingsChange:self];
  333.     }
  334.  
  335.     return self;
  336. }
  337.  
  338.  
  339.  
  340. - (double)contourLevelsIncr
  341. {
  342.     return s_levelsSeries.incr;
  343. }
  344.  
  345.  
  346.  
  347. - setContourLevelsEnd:(double)aDouble
  348. {
  349.     if (aDouble != s_levelsSeries.end) {
  350.     s_levelsSeries.end = aDouble;
  351.     [self reportSettingsChange:self];
  352.     }
  353.  
  354.     return self;
  355. }
  356.  
  357.  
  358.  
  359. - (double)contourLevelsEnd
  360. {
  361.     return s_levelsSeries.end;
  362. }
  363.  
  364.  
  365. - (DoubleValueSortedList *)levelDefs
  366. {
  367.     return levelDefs;
  368. }
  369.  
  370.  
  371.  
  372. - setContourInKey:(BOOL) cond
  373. {
  374.     if (cond != s_label_contours) {
  375.     s_label_contours = cond;
  376.     [self reportSettingsChange:self];
  377.     }
  378.  
  379.     return self;
  380. }
  381.  
  382.  
  383. - (BOOL)contourInKey
  384. {
  385.     return s_label_contours;
  386. }
  387.  
  388.  
  389.  
  390. // Shuts up the compiler about unused RCSId
  391. - (const char *) rcsid
  392. {
  393.     return RCSId;
  394. }
  395.  
  396.  
  397. @end
  398.